{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression with a Neural Network mindset\n",
    "\n",
    "Welcome to your first (required) programming assignment! You will build a logistic regression classifier to recognize  cats. This assignment will step you through how to do this with a Neural Network mindset, and so will also hone your intuitions about deep learning.\n",
    "\n",
    "**Instructions:**\n",
    "- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.\n",
    "\n",
    "**You will learn to:**\n",
    "- Build the general architecture of a learning algorithm, including:\n",
    "    - Initializing parameters\n",
    "    - Calculating the cost function and its gradient\n",
    "    - Using an optimization algorithm (gradient descent) \n",
    "- Gather all three functions above into a main model function, in the right order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Packages ##\n",
    "\n",
    "First, let's run the cell below to import all the packages that you will need during this assignment. \n",
    "- [numpy](www.numpy.org) is the fundamental package for scientific computing with Python.\n",
    "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n",
    "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python.\n",
    "- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from lr_utils import load_dataset\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2 - Overview of the Problem set ##\n",
    "\n",
    "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n",
    "    - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n",
    "    - a test set of m_test images labeled as cat or non-cat\n",
    "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n",
    "\n",
    "You will build a simple image-recognition algorithm that can correctly classify pictures as cat or non-cat.\n",
    "\n",
    "Let's get more familiar with the dataset. Load the data by running the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the data (cat/non-cat)\n",
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We added \"_orig\" at the end of image datasets (train and test) because we are going to preprocess them. After preprocessing, we will end up with train_set_x and test_set_x (the labels train_set_y and test_set_y don't need any preprocessing).\n",
    "\n",
    "Each line of your train_set_x_orig and test_set_x_orig is an array representing an image. You can visualize an example by running the following code. Feel free also to change the `index` value and re-run to see other images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = [1], it's a 'cat' picture.\n",
      "(209, 64, 64, 3)\n",
      "(1, 209)\n",
      "(50, 64, 64, 3)\n",
      "(1, 50)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ceb33a2b00>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 25\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")\n",
    "\n",
    "print (train_set_x_orig.shape)\n",
    "print( train_set_y.shape)\n",
    "print(test_set_x_orig.shape)\n",
    "print(test_set_y.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many software bugs in deep learning come from having matrix/vector dimensions that don't fit. If you can keep your matrix/vector dimensions straight you will go a long way toward eliminating many bugs. \n",
    "\n",
    "**Exercise:** Find the values for:\n",
    "    - m_train (number of training examples)\n",
    "    - m_test (number of test examples)\n",
    "    - num_px (= height = width of a training image)\n",
    "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 209\n",
      "Number of testing examples: m_test = 50\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (209, 64, 64, 3)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x shape: (50, 64, 64, 3)\n",
      "test_set_y shape: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "### START CODE HERE ### (≈ 3 lines of code)\n",
    "m_train = train_set_x_orig.shape[0]\n",
    "m_test = test_set_x_orig.shape[0]\n",
    "num_px = train_set_x_orig.shape[1]\n",
    "### END CODE HERE ###\n",
    "\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output for m_train, m_test and num_px**: \n",
    "<table style=\"width:15%\">\n",
    "  <tr>\n",
    "    <td>**m_train**</td>\n",
    "    <td> 209 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**m_test**</td>\n",
    "    <td> 50 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>**num_px**</td>\n",
    "    <td> 64 </td> \n",
    "  </tr>\n",
    "  \n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n",
    "\n",
    "**Exercise:** Reshape the training and test data sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n",
    "\n",
    "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n",
    "```python\n",
    "X_flatten = X.reshape(X.shape[0], -1).T      # X.T is the transpose of X\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set_x_flatten shape: (12288, 209)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x_flatten shape: (12288, 50)\n",
      "test_set_y shape: (1, 50)\n",
      "sanity check after reshaping: [17 31 56 22 33]\n"
     ]
    }
   ],
   "source": [
    "## Reshape the training and test examples\n",
    "\n",
    "### START CODE HERE ### (≈ 2 lines of code)  这个不懂啊......\n",
    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T\n",
    "### END CODE HERE ###\n",
    "\n",
    "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))\n",
    "print (\"sanity check after reshaping: \" + str(train_set_x_flatten[0:5,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:35%\">\n",
    "  <tr>\n",
    "    <td>**train_set_x_flatten shape**</td>\n",
    "    <td> (12288, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**train_set_y shape**</td>\n",
    "    <td>(1, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**test_set_x_flatten shape**</td>\n",
    "    <td>(12288, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>**test_set_y shape**</td>\n",
    "    <td>(1, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "  <td>**sanity check after reshaping**</td>\n",
    "  <td>[17 31 56 22 33]</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To represent color images, the red, green and blue channels (RGB) must be specified for each pixel, and so the pixel value is actually a vector of three numbers ranging from 0 to 255.\n",
    "\n",
    "One common preprocessing step in machine learning is to center and standardize your dataset, meaning that you substract the mean of the whole numpy array from each example, and then divide each example by the standard deviation of the whole numpy array. But for picture datasets, it is simpler and more convenient and works almost as well to just divide every row of the dataset by 255 (the maximum value of a pixel channel).\n",
    "\n",
    "<!-- During the training of your model, you're going to multiply weights and add biases to some initial inputs in order to observe neuron activations. Then you backpropogate with the gradients to train the model. But, it is extremely important for each feature to have a similar range such that our gradients don't explode. You will see that more in detail later in the lectures. !--> \n",
    "\n",
    "Let's standardize our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten/255.\n",
    "test_set_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**What you need to remember:**\n",
    "\n",
    "Common steps for pre-processing a new dataset are:\n",
    "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n",
    "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n",
    "- \"Standardize\" the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - General Architecture of the learning algorithm ##\n",
    "\n",
    "It's time to design a simple algorithm to distinguish cat images from non-cat images.\n",
    "\n",
    "You will build a Logistic Regression, using a Neural Network mindset. The following Figure explains why **Logistic Regression is actually a very simple Neural Network!**\n",
    "\n",
    "<img src=\"images/LogReg_kiank.png\" style=\"width:650px;height:400px;\">\n",
    "\n",
    "**Mathematical expression of the algorithm**:\n",
    "\n",
    "For one example $x^{(i)}$:\n",
    "$$z^{(i)} = w^T x^{(i)} + b \\tag{1}$$\n",
    "$$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\\tag{2}$$ \n",
    "$$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})\\tag{3}$$\n",
    "\n",
    "The cost is then computed by summing over all training examples:\n",
    "$$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})\\tag{6}$$\n",
    "\n",
    "**Key steps**:\n",
    "In this exercise, you will carry out the following steps: \n",
    "    - Initialize the parameters of the model\n",
    "    - Learn the parameters for the model by minimizing the cost  \n",
    "    - Use the learned parameters to make predictions (on the test set)\n",
    "    - Analyse the results and conclude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Building the parts of our algorithm ## \n",
    "\n",
    "The main steps for building a Neural Network are:\n",
    "1. Define the model structure (such as number of input features) \n",
    "2. Initialize the model's parameters\n",
    "3. Loop:\n",
    "    - Calculate current loss (forward propagation)\n",
    "    - Calculate current gradient (backward propagation)\n",
    "    - Update parameters (gradient descent)\n",
    "\n",
    "You often build 1-3 separately and integrate them into one function we call `model()`.\n",
    "\n",
    "### 4.1 - Helper functions\n",
    "\n",
    "**Exercise**: Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid( w^T x + b) = \\frac{1}{1 + e^{-(w^T x + b)}}$ to make predictions. Use np.exp()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: sigmoid\n",
    "\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Compute the sigmoid of z\n",
    "\n",
    "    Arguments:\n",
    "    z -- A scalar or numpy array of any size.\n",
    "\n",
    "    Return:\n",
    "    s -- sigmoid(z)\n",
    "    \"\"\"\n",
    "\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    s = 1/(1+np.exp(-z))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid([0, 2]) = [ 0.5         0.88079708]\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table>\n",
    "  <tr>\n",
    "    <td>**sigmoid([0, 2])**</td>\n",
    "    <td> [ 0.5         0.88079708]</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 - Initializing parameters\n",
    "\n",
    "**Exercise:** Implement parameter initialization in the cell below. You have to initialize w as a vector of zeros. If you don't know what numpy function to use, look up np.zeros() in the Numpy library's documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_with_zeros\n",
    "\n",
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
    "    \n",
    "    Argument:\n",
    "    dim -- size of the w vector we want (or number of parameters in this case)\n",
    "    \n",
    "    Returns:\n",
    "    w -- initialized vector of shape (dim, 1)\n",
    "    b -- initialized scalar (corresponds to the bias)\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    w = np.zeros((dim,1),dtype=float)\n",
    "    b = 0.0\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    assert(w.shape == (dim, 1))\n",
    "    assert(isinstance(b, float) or isinstance(b, int))\n",
    "    \n",
    "    return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[ 0.]\n",
      " [ 0.]]\n",
      "b = 0.0\n"
     ]
    }
   ],
   "source": [
    "dim = 2\n",
    "w, b = initialize_with_zeros(dim)\n",
    "print (\"w = \" + str(w))\n",
    "print (\"b = \" + str(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "\n",
    "<table style=\"width:15%\">\n",
    "    <tr>\n",
    "        <td>  ** w **  </td>\n",
    "        <td> [[ 0.]\n",
    " [ 0.]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** b **  </td>\n",
    "        <td> 0 </td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "For image inputs, w will be of shape (num_px $\\times$ num_px $\\times$ 3, 1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 - Forward and Backward propagation\n",
    "\n",
    "Now that your parameters are initialized, you can do the \"forward\" and \"backward\" propagation steps for learning the parameters.\n",
    "\n",
    "**Exercise:** Implement a function `propagate()` that computes the cost function and its gradient.\n",
    "\n",
    "**Hints**:\n",
    "\n",
    "Forward Propagation:\n",
    "- You get X\n",
    "- You compute $A = \\sigma(w^T X + b) = (a^{(0)}, a^{(1)}, ..., a^{(m-1)}, a^{(m)})$\n",
    "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)})$\n",
    "\n",
    "Here are the two formulas you will be using: \n",
    "\n",
    "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n",
    "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: propagate\n",
    "\n",
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    Implement the cost function and its gradient for the propagation explained above\n",
    "\n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
    "\n",
    "    Return:\n",
    "    cost -- negative log-likelihood cost for logistic regression\n",
    "    dw -- gradient of the loss with respect to w, thus same shape as w\n",
    "    db -- gradient of the loss with respect to b, thus same shape as b\n",
    "    \n",
    "    Tips:\n",
    "    - Write your code step by step for the propagation. np.log(), np.dot()\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    \n",
    "    # FORWARD PROPAGATION (FROM X TO COST)\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    #A = None            # compute activation\n",
    "    A=1/(1+np.exp(-1*(np.dot(w.T, X)+b)))\n",
    "  \n",
    "    cost = None         # compute cost\n",
    "    cost=(-1.0)/m*np.sum((Y*np.log(A)+(1-Y)*np.log(1-A)))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
    "    ### START CODE HERE ### (≈ 2 lines of code)\n",
    "    #dw = None\n",
    "    dw = (1/m)*(np.dot(X,((A-Y).T)))\n",
    "    #db = None\n",
    "    db = 1/m * np.sum(A-Y)\n",
    "    ### END CODE HERE ###\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return grads, cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[ 0.99993216]\n",
      " [ 1.99980262]]\n",
      "db = 0.499935230625\n",
      "cost = 6.00006477319\n"
     ]
    }
   ],
   "source": [
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table style=\"width:50%\">\n",
    "    <tr>\n",
    "        <td>  ** dw **  </td>\n",
    "        <td> [[ 0.99993216]\n",
    " [ 1.99980262]]</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** db **  </td>\n",
    "        <td> 0.499935230625 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>  ** cost **  </td>\n",
    "        <td> 6.000064773192205</td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# d) Optimization\n",
    "- You have initialized your parameters.\n",
    "- You are also able to compute a cost function and its gradient.\n",
    "- Now, you want to update the parameters using gradient descent.\n",
    "\n",
    "**Exercise:** Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: optimize\n",
    "\n",
    "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "    \"\"\"\n",
    "    This function optimizes w and b by running a gradient descent algorithm\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of shape (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
    "    num_iterations -- number of iterations of the optimization loop\n",
    "    learning_rate -- learning rate of the gradient descent update rule\n",
    "    print_cost -- True to print the loss every 100 steps\n",
    "    \n",
    "    Returns:\n",
    "    params -- dictionary containing the weights w and bias b\n",
    "    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
    "    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
    "    \n",
    "    Tips:\n",
    "    You basically need to write down two steps and iterate through them:\n",
    "        1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
    "        2) Update the parameters using gradient descent rule for w and b.\n",
    "    \"\"\"\n",
    "    \n",
    "    costs = []\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        \n",
    "        \n",
    "        # Cost and gradient calculation (≈ 1-4 lines of code)\n",
    "        ### START CODE HERE ### \n",
    "        #grads, cost = None\n",
    "        grads,cost = propagate(w,b,X,Y)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Retrieve derivatives from grads\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        # update rule (≈ 2 lines of code)\n",
    "        ### START CODE HERE ###\n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Record the costs\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        \n",
    "        # Print the cost every 100 training examples\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "    \n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return params, grads, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[ 0.1124579 ]\n",
      " [ 0.23106775]]\n",
      "b = 1.55930492484\n",
      "dw = [[ 0.90158428]\n",
      " [ 1.76250842]]\n",
      "db = 0.430462071679\n"
     ]
    }
   ],
   "source": [
    "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
    "\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\">\n",
    "    <tr>\n",
    "       <td> **w** </td>\n",
    "       <td>[[ 0.1124579 ]\n",
    " [ 0.23106775]] </td>\n",
    "    </tr>\n",
    "    \n",
    "    <tr>\n",
    "       <td> **b** </td>\n",
    "       <td> 1.55930492484 </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **dw** </td>\n",
    "       <td> [[ 0.90158428]\n",
    " [ 1.76250842]] </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "       <td> **db** </td>\n",
    "       <td> 0.430462071679 </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** The previous function will output the learned w and b. We are able to use w and b to predict the labels for a dataset X. Implement the `predict()` function. There is two steps to computing predictions:\n",
    "\n",
    "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n",
    "\n",
    "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: predict\n",
    "\n",
    "def predict(w, b, X):\n",
    "    '''\n",
    "    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    \n",
    "    Returns:\n",
    "    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
    "    '''\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "    w = w.reshape(X.shape[0], 1)\n",
    "    \n",
    "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
    "    ### START CODE HERE ### (≈ 1 line of code)\n",
    "    #A = None\n",
    "    A = sigmoid(np.dot(w.T, X) + b)\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    for i in range(A.shape[1]):\n",
    "        \n",
    "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
    "        ### START CODE HERE ### (≈ 4 lines of code)\n",
    "        if A[0,i] > 0.5:\n",
    "            Y_prediction[0,i] = 1\n",
    "        else:\n",
    "            Y_prediction[0,i] = 0\n",
    "        ### END CODE HERE ###\n",
    "    \n",
    "    assert(Y_prediction.shape == (1, m))\n",
    "    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[ 1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "print (\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:30%\">\n",
    "    <tr>\n",
    "         <td>\n",
    "             **predictions**\n",
    "         </td>\n",
    "          <td>\n",
    "            [[ 1.  1.]]\n",
    "         </td>  \n",
    "   </tr>\n",
    "\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<font color='blue'>\n",
    "**What to remember:**\n",
    "You've implemented several functions that:\n",
    "- Initialize (w,b)\n",
    "- Optimize the loss iteratively to learn parameters (w,b):\n",
    "    - computing the cost and its gradient \n",
    "    - updating the parameters using gradient descent\n",
    "- Use the learned (w,b) to predict the labels for a given set of examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - Merge all functions into a model ##\n",
    "\n",
    "You will now see how the overall model is structured by putting together all the building blocks (functions implemented in the previous parts) together, in the right order.\n",
    "\n",
    "**Exercise:** Implement the model function. Use the following notation:\n",
    "    - Y_prediction for your predictions on the test set\n",
    "    - Y_prediction_train for your predictions on the train set\n",
    "    - w, costs, grads for the outputs of optimize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: model\n",
    "\n",
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "    \"\"\"\n",
    "    Builds the logistic regression model by calling the function you've implemented previously\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
    "    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
    "    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
    "    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
    "    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
    "    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
    "    print_cost -- Set to true to print the cost every 100 iterations\n",
    "    \n",
    "    Returns:\n",
    "    d -- dictionary containing information about the model.\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # initialize parameters with zeros (≈ 1 line of code)\n",
    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
    "\n",
    "    # Gradient descent (≈ 1 line of code)\n",
    "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
    "    \n",
    "    # Retrieve parameters w and b from dictionary \"parameters\"\n",
    "    w = parameters[\"w\"]\n",
    "    b = parameters[\"b\"]\n",
    "    \n",
    "    # Predict test/train set examples (≈ 2 lines of code)\n",
    "    Y_prediction_test = predict(w, b, X_test)\n",
    "    Y_prediction_train = predict(w, b, X_train)\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # Print train/test Errors\n",
    "    print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
    "    print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
    "\n",
    "    \n",
    "    d = {\"costs\": costs,\n",
    "         \"Y_prediction_test\": Y_prediction_test, \n",
    "         \"Y_prediction_train\" : Y_prediction_train, \n",
    "         \"w\" : w, \n",
    "         \"b\" : b,\n",
    "         \"learning_rate\" : learning_rate,\n",
    "         \"num_iterations\": num_iterations}\n",
    "    \n",
    "    return d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following cell to train your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.584508\n",
      "Cost after iteration 200: 0.466949\n",
      "Cost after iteration 300: 0.376007\n",
      "Cost after iteration 400: 0.331463\n",
      "Cost after iteration 500: 0.303273\n",
      "Cost after iteration 600: 0.279880\n",
      "Cost after iteration 700: 0.260042\n",
      "Cost after iteration 800: 0.242941\n",
      "Cost after iteration 900: 0.228004\n",
      "Cost after iteration 1000: 0.214820\n",
      "Cost after iteration 1100: 0.203078\n",
      "Cost after iteration 1200: 0.192544\n",
      "Cost after iteration 1300: 0.183033\n",
      "Cost after iteration 1400: 0.174399\n",
      "Cost after iteration 1500: 0.166521\n",
      "Cost after iteration 1600: 0.159305\n",
      "Cost after iteration 1700: 0.152667\n",
      "Cost after iteration 1800: 0.146542\n",
      "Cost after iteration 1900: 0.140872\n",
      "train accuracy: 99.04306220095694 %\n",
      "test accuracy: 70.0 %\n"
     ]
    }
   ],
   "source": [
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:40%\"> \n",
    "    \n",
    "    <tr>\n",
    "        <td> **Train Accuracy**  </td> \n",
    "        <td> 99.04306220095694 % </td>\n",
    "    </tr>\n",
    "\n",
    "    <tr>\n",
    "        <td>**Test Accuracy** </td> \n",
    "        <td> 70.0 % </td>\n",
    "    </tr>\n",
    "</table> \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Comment**: Training accuracy is close to 100%. This is a good sanity check: your model is working and has high enough capacity to fit the training data. Test error is 68%. It is actually not bad for this simple model, given the small dataset we used and that logistic regression is a linear classifier. But no worries, you'll build an even better classifier next week!\n",
    "\n",
    "Also, you see that the model is clearly overfitting the training data. Later in this specialization you will learn how to reduce overfitting, for example by using regularization. Using the code below (and changing the `index` variable) you can look at predictions on pictures of the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-102-50a2ff1ec91d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mindex\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_set_x\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_px\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"y = \"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_set_y\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;34m\", you predicted that it is a \\\"\"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mclasses\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"Y_prediction_test\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"utf-8\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m  \u001b[1;34m\"\\\" picture.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ceb5274320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture that was wrongly classified.\n",
    "index = 1\n",
    "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[d[\"Y_prediction_test\"][0,index]].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also plot the cost function and the gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzt3Xd8XPWZ7/HPI8mSLFuSVV0kWe52bMAYC2xjEkwJMYRQEkwJBAJJnMbNTdm7y73ZzXLJZm822d1sEshmCTUbQk+IKQmhGIgxxpaNC25Y7nKVu9wl67l/nCNlLEbN1sxImu/79ZqXZs75zZlnjqT5zu+U3zF3R0REBCAl0QWIiEjXoVAQEZEmCgUREWmiUBARkSYKBRERaaJQEBGRJgoF6ZHM7I9mdlui6xDpbhQK0qnMbIOZXZroOtz9cnd/NNF1AJjZG2b2xTi8ToaZPWRmB8xsu5l9u4323wrb7Q+flxExb4iZzTazw2a2KvJ3amafN7MTZnYw4jYthm9N4kihIN2OmaUluoZGXakW4G5gJFAOXAT8rZlNj9bQzD4B3AVcAgwBhgH/N6LJ48B7QAHwXeAZMyuKmP+Ou/eNuL3RuW9FEkWhIHFjZlea2WIz22dmc83srIh5d5nZWjOrNbMVZnZtxLzPm9nbZvYTM9sD3B1Om2Nm/2pme81svZldHvGcpm/n7Wg71MzeCl/7VTO7z8x+08J7mGZm1Wb2d2a2HXjYzPLM7AUzqwmX/4KZlYbtfwB8FLg3/EZ9bzh9jJm9YmZ7zGy1mV3fCav4VuD77r7X3VcCvwI+30Lb24AH3X25u+8Fvt/Y1sxGAecA/+juR9z9WWAZ8JlOqFG6OIWCxIWZnQM8BHyZ4NvnfwGzIjZZrCX48Mwl+Mb6GzMbGLGIScA6oBj4QcS01UAh8CPgQTOzFkpore1vgflhXXcDn2vj7QwA8gm+kc8k+D96OHw8GDgC3Avg7t8F/gLcGX6jvtPM+gCvhK9bDNwE/MLMxkV7MTP7RRik0W5LwzZ5wCBgScRTlwBRlxlOb962v5kVhPPWuXttK8uaYGa7zOwDM/uHLtZjktOgUJB4+RLwX+7+rrufCLf3HwMmA7j70+6+1d0b3P1JYA1wXsTzt7r7z9293t2PhNM2uvuv3P0E8CgwEOjfwutHbWtmg4Fzge+5+3F3nwPMauO9NBB8iz4WfpPe7e7Puvvh8IP0B8CFrTz/SmCDuz8cvp9FwLPAddEau/vX3L1fC7fG3lbf8Of+iKfuB7JbqKFvlLaE7ZvPa76st4AzCALtMwSh9r9aeb/SjSgUJF7Kge9EfssFygi+3WJmt0ZsWtpH8KFTGPH8zVGWub3xjrsfDu/2jdKutbaDgD0R01p6rUg17n608YGZZZnZf5nZRjM7QPCh2c/MUlt4fjkwqdm6uJmgB3KqDoY/cyKm5QC1Udo2tm/elrB983knLcvd17n7+jDAlwH30EKgSfejUJB42Qz8oNm33Cx3f9zMygm2f98JFLh7P+B9IHJTUKyG890G5JtZVsS0sjae07yW7wCjgUnungN8LJxuLbTfDLzZbF30dfevRnsxM/tlsyN9Im/LAcL9AtuA8RFPHQ8sb+E9LI/Sdoe77w7nDTOz7GbzW1qWc/LvSroxhYLEQi8zy4y4pRF86H/FzCZZoI+ZfTL84OlD8MFSA2BmtxP0FGLO3TcClQQ7r9PNbArwqQ4uJptgP8I+M8sH/rHZ/B0ER/c0egEYZWafM7Ne4e1cM/tICzV+pdmRPpG3yO38vwb+PtzxPYZgk90jLdT8a+ALZjY23B/x941t3f0DYDHwj+Hv71rgLIJNXJjZ5WbWP7w/BvgH4A/tWE/SDSgUJBZeIviQbLzd7e6VBB9S9wJ7gSrCo13cfQXwb8A7BB+gZwJvx7Hem4EpwG7gn4AnCfZ3tNd/AL2BXcA84E/N5v8UuC48Muln4X6Hy4Abga0Em7b+Bcjg9PwjwQ77jcCbwI/d/U8AZjY47FkMBgin/wiYHbbfyMlhdiNQQfC7+iFwnbvXhPMuAZaa2SGC3/XvgH8+zdqlizBdZEfkZGb2JLDK3Zt/4xfp8dRTkKQXbroZbmYpFpzsdTXwXKLrEkkEHVssEhz18zuC8xSqga+6+3uJLUkkMbT5SEREmmjzkYiINOl2m48KCwt9yJAhiS5DRKRbWbhw4S53L2qrXbcLhSFDhlBZWZnoMkREuhUz29iedtp8JCIiTRQKIiLSRKEgIiJNYhoKZjY9vIBIlZndFWX+T8KRMReH47Lvi2U9IiLSupjtaA6HDb4P+DjBCUELzGxWOM4NAO7+rYj2/wOYEKt6RESkbbHsKZwHVIVjrx8HniAYPqAlNxFcF1ZERBIklqFQwskXK6kOp31IOJ7+UOD1FubPNLNKM6usqamJ1kRERDpBLEMh2kU3WhpT40bgmfBSiR9+kvv97l7h7hVFRW2eexHVks37+Jc/rTql54qIJItYhkI1J1/BqpRg7PhobiTGm46WVO/jP99Yy5LN2pctItKSWIbCAmCkmQ01s3SCD/4PXRDdzEYDeQQXWImZayeUkJWeym/mteukPhGRpBSzUHD3eoJr7r4MrASecvflZnaPmV0V0fQm4AmP8XCt2Zm9uGZCCbOWbGXf4eOxfCkRkW4rpucpuPtL7j7K3Ye7+w/Cad9z91kRbe529w+dwxALt0wq51h9A88srI7Hy4mIdDtJdUbz2EE5TCzP47F3N9HQoOtIiIg0l1ShAPC5yeWs33WIuWt3J7oUEZEuJ+lC4fIzB5DfJ53/nrch0aWIiHQ5SRcKGWmpzKgo5dWVO9m2/0iiyxER6VKSLhQAbj6vnAZ3Hp+/ue3GIiJJJClDYXBBFheOKuKJ+ZuoO9GQ6HJERLqMpAwFCHY476w9xisrdiS6FBGRLiNpQ2Ha6GJK+vXWGc4iIhGSNhRSU4zPThrM3LW7qdp5MNHliIh0CUkbCgA3nFtGr1TjsXfVWxARgSQPhcK+GVx+xkCeWVjN4eP1iS5HRCThkjoUAG6ZXE7t0XqeX9LSqN4iIskj6UPh3CF5jO6fzX/P20iMB2oVEenykj4UzIxbJg/m/S0HWFK9P9HliIgkVNKHAsA1E0roowvwiIgoFOCvF+B5XhfgEZEkp1AI3TJZF+AREVEohD4yMIeK8jx+M2+jLsAjIklLoRDhlsnlbNh9mLfX7kp0KSIiCaFQiNB0AZ53tMNZRJKTQiFCRloq11eU8erKHboAj4gkJYVCMzdPGowDj7+7KdGliIjEnUKhmbL8LKaNKuLxBZt1AR4RSToKhSg+N6Wcmtpj/Hm5LsAjIslFoRDFhaN0AR4RSU4KhShSU4ybJw/mnXW7qdpZm+hyRETiJqahYGbTzWy1mVWZ2V0ttLnezFaY2XIz+20s6+mI6yuCC/D8Zp52OItI8ohZKJhZKnAfcDkwFrjJzMY2azMS+N/AVHcfB3wzVvV0VOMFeJ5dpAvwiEjyiGVP4Tygyt3Xuftx4Ang6mZtvgTc5+57Adx9Zwzr6bDPTQkuwDNrsS7AIyLJIZahUAJsjnhcHU6LNAoYZWZvm9k8M5sew3o6rKJcF+ARkeQSy1CwKNOaf7KmASOBacBNwANm1u9DCzKbaWaVZlZZU1PT6YW2xMy4ZUo5y7ceYPHmfXF7XRGRRIllKFQDZRGPS4Hm22GqgT+4e527rwdWE4TESdz9fnevcPeKoqKimBUczbVNF+DRDmcR6fliGQoLgJFmNtTM0oEbgVnN2jwHXARgZoUEm5PWxbCmDuubkca155Tw/NKt7D2kC/CISM8Ws1Bw93rgTuBlYCXwlLsvN7N7zOyqsNnLwG4zWwHMBv6Xu++OVU2n6pbJ5RzXBXhEJAlYd9uBWlFR4ZWVlXF/3Rm/nMvO2mPM/s40UlKi7S4REem6zGyhu1e01U5nNLfTzZPK2bj7MPPWd7mOjIhIp1EotNP0MwaQnZnGM5XahCQiPZdCoZ0ye6XyqfGDeOn9bRw4WpfockREYkKh0AHXV5RxtK6BF5duS3QpIiIxoVDogPGluYws7stTlZvbbiwi0g0pFDrAzLi+ooz3Nu3TkNoi0iMpFDromgklpKYYT2uHs4j0QAqFDirKzuDiMcU8u2iLruEsIj2OQuEUzJhYyq6Dx3hzdfwG5xMRiQeFwim4aEwxhX3TeXqhdjiLSM+iUDgFvVJTuHZCCa+t3Mmug8cSXY6ISKdRKJyiGRVl1Dc4z723JdGliIh0GoXCKRrVP5vxZf14urJaV2UTkR5DoXAaZkwsZfWOWpZt2Z/oUkREOoVC4TR8avwgMtJSdIaziPQYCoXTkNu7F9PPGMCsxVs5Wnci0eWIiJw2hcJpur6ijANH6/nzih2JLkVE5LQpFE7TlGEFlPTrzdPahCQiPYBC4TSlpBjXTSxlTtUutuw7kuhyREROi0KhE1w3sRR3eHahBskTke5NodAJyvKzOH94Ac8srKahQecsiEj3pVDoJDMqStm05zDvrt+T6FJERE6ZQqGTTB83kOyMNA2SJyLdmkKhk/ROT+XK8YN4adk2ao/WJbocEZFTolDoRNdXlHK0roEXl25LdCkiIqdEodCJzi7rx4jivhr2QkS6LYVCJzIzZkwsZdGmfVTtPJjockREOiymoWBm081stZlVmdldUeZ/3sxqzGxxePtiLOuJh2vPKSE1xbTDWUS6pZiFgpmlAvcBlwNjgZvMbGyUpk+6+9nh7YFY1RMvxdmZXDS6iN8t2kL9iYZElyMi0iGx7CmcB1S5+zp3Pw48AVwdw9frMmZUlFFTe4w3P6hJdCkiIh0Sy1AoASK3oVSH05r7jJktNbNnzKws2oLMbKaZVZpZZU1N1/+gvXhMMQV90nm6UsNeiEj3EstQsCjTmo8B8TwwxN3PAl4FHo22IHe/390r3L2iqKiok8vsfL1SU7h2QgmvrdrB7oPHEl2OiEi7xTIUqoHIb/6lwNbIBu6+290bPzV/BUyMYT1xNaOijLoTznOLt7bdWESki4hlKCwARprZUDNLB24EZkU2MLOBEQ+vAlbGsJ64Gj0gm/GluTxduRl3DZInIt1DzELB3euBO4GXCT7sn3L35WZ2j5ldFTb7hpktN7MlwDeAz8eqnkS4rqKMVdtreX/LgUSXIiLSLtbdvsVWVFR4ZWVlostol/1H6jjvB69yw7ll3HP1GYkuR0SSmJktdPeKttrpjOYYyu3di0+MG8Bz723haN2JRJcjItImhUKMXV9RxoGj9byyYkeiSxERaZNCIcbOH15ASb/eGiRPRLoFhUKMpaQYn5lYypyqXWzddyTR5YiItEqhEAczJpbiDs8u1BnOItK1KRTioCw/i8nD8nl6YTUNDd3raC8RSS4KhTi56bzBbNpzmFdXaoeziHRdCoU4+eSZAxlSkMXPXl+jM5xFpMtSKMRJWmoKX79oBO9vOcDs1TsTXY6ISFQKhTi6ZkIJZfm9+elrVeotiEiXpFCIo16pKXx92giWbN7HW2t2JbocEZEPUSjE2afPKaWkX29++uoH6i2ISJejUIiz9LQUvjptOIs27WPu2t2JLkdE5CQKhQSYUVHKgJxMfvramkSXIiJyEoVCAmSkpfLVacOZv34P89aptyAiXYdCIUFuOLeM4uwMfqbegoh0Ie0KBTOb0Z5p0n6ZvVL58oXDmbt2Nws27El0OSIiQPt7Cv+7ndOkAz573mAK+6artyAiXUZaazPN7HLgCqDEzH4WMSsHqI9lYcmgd3oqMz82jH9+aRWLNu3lnMF5iS5JRJJcWz2FrUAlcBRYGHGbBXwitqUlh5snlZOX1Yufq7cgIl1Aqz0Fd18CLDGz37p7HYCZ5QFl7r43HgX2dH0y0vjiR4fx45dXs7R6H2eV9kt0SSKSxNq7T+EVM8sxs3xgCfCwmf17DOtKKrdOKSe3dy9+9lpVoksRkSTX3lDIdfcDwKeBh919InBp7MpKLtmZvfjCBUN5deUO3t+yP9HliEgSa28opJnZQOB64IUY1pO0bjt/CNmZadz7unoLIpI47Q2Fe4CXgbXuvsDMhgHaM9qJcnv34vapQ/nT8u2s2n4g0eWISJJqVyi4+9Pufpa7fzV8vM7dPxPb0pLPHVOH0DcjjZ+rtyAiCdLeM5pLzez3ZrbTzHaY2bNmVhrr4pJNv6x0bju/nJeWbWPNjtpElyMiSai9m48eJjg3YRBQAjwfTmuVmU03s9VmVmVmd7XS7jozczOraGc9PdYXLhhG716p3DtbvQURib/2hkKRuz/s7vXh7RGgqLUnmFkqcB9wOTAWuMnMxkZplw18A3i3Q5X3UPl90vnclHKeX7KVtTUHE12OiCSZ9obCLjO7xcxSw9stQFtjPp8HVIX7H44DTwBXR2n3feBHBGdNC/Cljw4jPS2F+9RbEJE4a28o3EFwOOp2YBtwHXB7G88pATZHPK4OpzUxswkEZ0e3epirmc00s0ozq6ypqWlnyd1XYd8MbplUzh8Wb2XDrkOJLkdEkkh7Q+H7wG3uXuTuxQQhcXcbz7Eo05ouSmxmKcBPgO+09eLufr+7V7h7RVFRq1uteoyZHxtGWorxizfUWxCR+GlvKJwVOdaRu+8BJrTxnGqgLOJxKcEAe42ygTOAN8xsAzAZmKWdzYHinExuOm8wv1u0hc17Die6HBFJEu0NhZRwIDwAwjGQWh1MD1gAjDSzoWaWDtxIcAQTAO6+390L3X2Iuw8B5gFXuXtlh95BD/aVC4eTYsYv3lib6FJEJEm0NxT+DZhrZt83s3uAuQQ7h1vk7vXAnQRnQq8EnnL35WZ2j5lddTpFJ4sBuZnccG4ZzyzczJZ9RxJdjogkAXP3tlsB4eGkFxPsK3jN3VfEsrCWVFRUeGVl8nQmtuw7wrQfz+bGcwfz/WvOSHQ5ItJNmdlCd29z83xbm4CahCGQkCBIZiX9enPdxDKeXLCZr180ggG5mYkuSUR6sPZuPpIE+tq04TS488s3tW9BRGJLodANlOVn8elzSvjt/E0s2qQL3olI7CgUuom/uWw0A3MzufXB+SzcqGAQkdhQKHQTxTmZPDFzMgV907ntofks3Lgn0SWJSA+kUOhGBub25smZUyjsmx72GBQMItK5FArdzIDcTJ6YOYXinGBTUuUGBYOIdB6FQjc0IDeTx780meKcTG57aD4LFAwi0kkUCt1U0GOYTP8wGOavVzCIyOlTKHRj/cOdzwNyM/n8w/N5d11bl7gQEWmdQqGbK87J5IkvTWZgbia3P7JAwSAip0Wh0AMU52Ty+MwgGD7/8ALmKRhE5BQpFHqI4uwgGEryenP7wwt4Z62CQUQ6TqHQgxRnB0clleb15o5HFjB37a5ElyQi3YxCoYcpys7gt5HBUKVgEJH2Uyj0QEXZGTw+czKD87O449EFvK1gEJF2Uij0UIV9gx5DeX4f7nhEwSAi7aNQ6MGCYJjE0MIgGOasUTCISOsUCj1cQd8MHvtiGAyPLuC+2VUcr29IdFki0kUpFJJAQd8MHv/SZC79SDE/fnk1V/78LxphVUSiUigkibw+6fzi5ok8cGsFB4/Wc90v3+G7v1/G/iN1iS5NRLoQhUKSuXRsf1759oXcfv5QHp+/iY//+5u8tGwb7p7o0kSkC1AoJKE+GWl871Nj+cPXL6AoO4OvPbaILz5ayZZ9RxJdmogkmEIhiZ1Zmssfvj6V717xEeau3c3H//1NHpyznhMN6jWIJCuFQpJLS03hSx8bxp+/9TEmDc3n+y+s4Jr73ub9LfsTXZqIJIBCQQAoy8/ioc+fy72fncC2/Ue56t45/NMLKzh0rD7RpYlIHCkUpImZceVZg3jt2xdyw7mDeWDOei77yVvMXrUz0aWJSJzENBTMbLqZrTazKjO7K8r8r5jZMjNbbGZzzGxsLOuR9snN6sX/+/SZPP2VKfROT+X2Rxbw9d8uYmft0USXJiIxZrE6FNHMUoEPgI8D1cAC4CZ3XxHRJsfdD4T3rwK+5u7TW1tuRUWFV1ZWxqRm+bBj9Sf4rzfXce/rVWSkpfDlC4dx+9Sh9MlIS3RpItIBZrbQ3SvaahfLnsJ5QJW7r3P348ATwNWRDRoDIdQH0GEvXUxGWirfuGQkf/rmR5k0LJ9//fMHXPjj2Tw0Zz1H604kujwR6WSxDIUSYHPE4+pw2knM7Otmthb4EfCNaAsys5lmVmlmlTU1NTEpVlo3rKgvD9x2Lr/72vmMLM7mnhdWcPG/vsGTCzZRf0JjKYn0FLEMBYsy7UM9AXe/z92HA38H/H20Bbn7/e5e4e4VRUVFnVymdMQ5g/N4fOZkHvviJIpyMvm7Z5fx8Z+8xawlW2nQ+Q0i3V4sQ6EaKIt4XApsbaX9E8A1MaxHOtHUEYU897Xzuf9zE0lPTeEbj7/HFT/7C6+t3KEhM0S6sViGwgJgpJkNNbN04EZgVmQDMxsZ8fCTwJoY1iOdzMy4bNwAXvqfH+U/bjibI3Un+MKjlXz6P+fq+tAi3VTMDiFx93ozuxN4GUgFHnL35WZ2D1Dp7rOAO83sUqAO2AvcFqt6JHZSU4xrJpTwybMG8nRlNT97bQ2f/dW7XDCikL/5xGjOLuuX6BJFpJ1idkhqrOiQ1K7vaN0JfjNvI/fNrmLv4TouG9uf71w2mtEDshNdmkjSau8hqQoFiZnao3U8NGcDD/xlHQeP13P1+EF8+cLhfGRgTqJLE0k6CgXpMvYeOs4v31rLr+du5EjdCaaOKOALFwxl2qhiUlKiHaQmIp1NoSBdzr7Dx/nt/E08OncDOw4cY1hRH+6YOpTPnFNK7/TURJcn0qMpFKTLOl7fwEvLtvHAnHW8v+UA/bJ6ccukcm6dUk5xTmaiyxPpkRQK0uW5O/PX7+HBOet5ZeUO0lKMT501iDsuGMoZJbmJLk+kR2lvKGhUM0kYM2PSsAImDStgw65DPDJ3A09VbuZ3721h8rB8vnjBMC4eo/0OIvGknoJ0KfsP1/HEgk08MncD2/YfZWhhH+6YOoTPTCwlK13fYUROlTYfSbdWd6KBP76/nQf/so4l1fvJ7d2Lm84bzE3nlVFe0CfR5Yl0OwoF6RHcnYUb9/LgnPW8vHw7DQ6ThuZzfUUZl585QL0HkXZSKEiPs23/EX63aAtPVW5m4+7D9M1I48qzBjKjooxzBvfDTPseRFqiUJAey91ZsGEvT1Vu5sWl2zhSd4LhRX24vqKMa88poThbh7WKNKdQkKRw8Fg9Ly7dytOV1VRu3EtqinHR6GJmVJRy8ZhieqXG9DLkIt2GQkGSztqagzxdWc2zi6qpqT1GYd90rp1QwoyKMkb112B8ktwUCpK06k808OYHNTxdWc2rK3dQ3+CML+vHjImlXHHmQPL7pCe6RJG4UyiIALsOHuO594Kd0x/sOEhqinH+8AI+eeZAPjFuAHkKCEkSCgWRCO7O8q0HeGnZNl5cto2Nuw8rICSpKBREWtAYEC8u28ZLzQLiyrMGctlYBYT0PAoFkXaIFhBpKcb5Iwr55JkDFBDSYygURDooMiBeXLqNTXsUENJzKBRETkNjQLywNOhBbNoTbGKqKM/jko8Uc/GYYoYX9dVZ1NJtKBREOom78/6WA/zx/W28vmonq7bXAjA4P4uLxxRz0ZhiJg3NJ7OXrh4nXZdCQSRGtuw7wuxVO5m9aidvr93F0boGstJTmTqikIvHBL2I/rqCnHQxCgWRODhad4J31u7m9VU7eX3VTrbsOwLAuEE5XBL2IsaX9tOFgiThFAoicebufLDjIK+t2sHsVTtZuHEvDQ4FfdKZNjroQUwdUUC/LO2slvhTKIgk2N5Dx3lrTQ2vr9rJG6tr2H+kDrOgFzF1eCHnjyjkvCH59E7XvgiJPYWCSBdSf6KBxZv38XbVbt5eu4v3Nu2l7oTTK9WYMDiPC0YUMnVEAWeV9tPIrhITCgWRLuzw8XoWbNjL3KpdvL12F8u3HsAd+qSnMmlYAecPL2DqiEJG98/W/gjpFO0NhZhey9DMpgM/BVKBB9z9h83mfxv4IlAP1AB3uPvGWNYk0hVkpadx4agiLhxVBASbmt5Zt5u3q3YxN9xxDcH+iCnDC8KeRCGleb11boTEVMx6CmaWCnwAfByoBhYAN7n7iog2FwHvuvthM/sqMM3db2htueopSDLYuu9IU0C8XbWLnbXHABiYm0nFkHzOHZLHuUPyGdU/m1T1JKQdukJP4Tygyt3XhQU9AVwNNIWCu8+OaD8PuCWG9Yh0G4P69WZGRRkzKspwd6p2HuSddbuZv34P89fv5vklWwHIzkxjYnkQEOcOyees0lydRCenJZahUAJsjnhcDUxqpf0XgD9Gm2FmM4GZAIMHD+6s+kS6BTNjZP9sRvbP5tYpQ3B3qvceoXLjHuav30vlhj28sXo1AOmpKZxZmhuGRB4Ty/N0CKx0SCxDIVqfNuq2KjO7BagALow2393vB+6HYPNRZxUo0h2ZGWX5WZTlZ3HthFIg2CexcONeFmzYw4INe3hwzjp++WbwrzK6fzYV4eams8v6UV6Qpf0S0qJYhkI1UBbxuBTY2ryRmV0KfBe40N2PxbAekR4rr086l47tz6Vj+wPBmdZLNu+jcuNe5q/fw6zFW3ns3U0A9MvqxfjSfpxdFtzGl/XTJUqlSSx3NKcR7Gi+BNhCsKP5s+6+PKLNBOAZYLq7r2nPcrWjWaTjTjQ4H+yoZfHmfSzZvI/Fm/fxwY5aGsJ//8H5WYwv68f40lwmDO7HuEHaN9HTdInzFMzsCuA/CA5Jfcjdf2Bm9wCV7j7LzF4FzgS2hU/Z5O5XtbZMhYJI5zh0rJ5lW/Y3hcSSzfvYuv8oAGkpxpiB2YwvDXoSE8r6Mbyor86Z6Ma6RCjEgkJBJHZ2HjgaBER1EBRLN++n9lg9AH0z0hg7MIdxJTmMG5TLGSU5DC/qqzOwu4mucEiqiHQzxTmZXDZuAJeNGwBAQ4OzbtdBFm8OehTLt+7n8fmbOFrXAEB6WgpjBmQzblAu4wblcEZJLmMGZGvTUzemnoKIdMiJBmf9roMs33qA97fsZ/nWAyzfeoD9R+oASE0xRhT1ZdygHMaGQTF2UA45mb0SXHly0+YjEYmbxnMngoCjnbOgAAAM6klEQVTY3/Rzx4G/HlA4OD+LMQOyGTMgm9EDchg9IJshBVmkafNTXGjzkYjETeS5E9PPGNA0vab2WFNIrNh6gFXbD/Dqyh1NRz1lpKUwsn9fRvfPCcMiCI2i7AydS5Eg6imISFwdrTtB1c6DrNpey+rtB8KftU3jOwHkZfUKAyLoUYwekM3o/tn0ydD32FOlnoKIdEmZvVI5oySXM0pyT5q+99DxpqBYvaOWldtqeapyM4ePn2hqU9KvN8OL+zKyuC8jGm9FfcnTyXedRqEgIl1CXjhM+JThBU3TGhqCfRWrth9g9fZaqmoOUrXzIPPX7246AgqgsG86w4uCkAgCI5sRxX3pn6PNUB2lUBCRLislxRhckMXggqymw2QhCIst+45QtfNg023NzlqeX7KVA0frm9plZ6QxPKJXMaywD8OK+lCWn0VGmg6bjUahICLdTkrKX3dsXzSmuGm6u1Nz8NhJYVG18yBvfVDDMwur//p8g9K8LIYW9mFoGBSN9wfl9k7qM7cVCiLSY5gZxdmZFGdncv7wwpPm7T9Sx4Zdh1i/6xDrwp/rdx2kcsMeDkXst8hIS2FIQRgSYVgMCwMjv096j98cpVAQkaSQ27tXMOhfWb+Tprs7NbXHIoLiEOtqDrFmZy2vrdpB3Ym/HqGZnZFGWX4W5eEmrfL8PpQXBI8H5vbuEVfBUyiISFIzM4pzMinOyWTysIKT5tWfaGDLviOsC4Ni0+5DbNxzmNXba3l15cmB0SvVKMtrDIssBhf0oTwMkLL8rG4z9IdCQUSkBWmpKZQX9KG8oA8XjT553okGZ9v+I2zafZiNew6zcfdhNu05xMbdh1m4YW/TQIKNBuRkUpbfm7K8LErzelOal0Vp+HhgbmaXObNboSAicgpSUyz4YM/L4vxm89ydvYfr2Lj7EJvCwNi4+zDVew/z7vo9PLf4SNNZ3Y3LGpCTSWleb8ryg9BoCo/8LAbkZMZt05RCQUSkk5kZ+X3Sye+TzoTBeR+aX3eige37j7J5z2Gq9x5h897w557DzFmzix21R4kcbCItxRjUrzffuWwUV59dEtPaFQoiInHWKzWl6ZDaaI7Vn2DrvqNU7z3M5j1Hgp97j1DYNyPmtSkURES6mIy01KbzJuKta+zZEBGRLkGhICIiTRQKIiLSRKEgIiJNFAoiItJEoSAiIk0UCiIi0kShICIiTcwjz6XuBsysBth4ik8vBHZ1YjmdTfWdHtV3+rp6jarv1JW7e1FbjbpdKJwOM6t094pE19ES1Xd6VN/p6+o1qr7Y0+YjERFpolAQEZEmyRYK9ye6gDaovtOj+k5fV69R9cVYUu1TEBGR1iVbT0FERFqhUBARkSY9MhTMbLqZrTazKjO7K8r8DDN7Mpz/rpkNiWNtZWY228xWmtlyM/ufUdpMM7P9ZrY4vH0vXvWFr7/BzJaFr10ZZb6Z2c/C9bfUzM6JY22jI9bLYjM7YGbfbNYm7uvPzB4ys51m9n7EtHwze8XM1oQ/P3xdxqDdbWGbNWZ2W5xq+7GZrQp/f783s34tPLfVv4UY13i3mW2J+D1e0cJzW/1/j2F9T0bUtsHMFrfw3Lisw07j7j3qBqQCa4FhQDqwBBjbrM3XgF+G928EnoxjfQOBc8L72cAHUeqbBryQwHW4AShsZf4VwB8BAyYD7ybwd72d4KSchK4/4GPAOcD7EdN+BNwV3r8L+Jcoz8sH1oU/88L7eXGo7TIgLbz/L9Fqa8/fQoxrvBv4m3b8DbT6/x6r+prN/zfge4lch51164k9hfOAKndf5+7HgSeAq5u1uRp4NLz/DHCJmVk8inP3be6+KLxfC6wEYnsl7s53NfBrD8wD+pnZwATUcQmw1t1P9Qz3TuPubwF7mk2O/Dt7FLgmylM/Abzi7nvcfS/wCjA91rW5+5/dvT58OA8o7czX7KgW1l97tOf//bS1Vl/42XE98Hhnv24i9MRQKAE2Rzyu5sMfuk1twn+M/UBBXKqLEG62mgC8G2X2FDNbYmZ/NLNxcS0MHPizmS00s5lR5rdnHcfDjbT8j5jI9deov7tvg+DLAFAcpU1XWJd3EPT8omnrbyHW7gw3cT3Uwua3rrD+PgrscPc1LcxP9DrskJ4YCtG+8Tc/7rY9bWLKzPoCzwLfdPcDzWYvItgkMh74OfBcPGsDprr7OcDlwNfN7GPN5neF9ZcOXAU8HWV2otdfRyR0XZrZd4F64LEWmrT1txBL/wkMB84GthFsomku4X+LwE203ktI5DrssJ4YCtVAWcTjUmBrS23MLA3I5dS6rqfEzHoRBMJj7v675vPd/YC7HwzvvwT0MrPCeNXn7lvDnzuB3xN00SO1Zx3H2uXAInff0XxGotdfhB2Nm9XCnzujtEnYugx3al8J3Ozhxu/m2vG3EDPuvsPdT7h7A/CrFl47oX+L4efHp4EnW2qTyHV4KnpiKCwARprZ0PDb5I3ArGZtZgGNR3lcB7ze0j9FZwu3Pz4IrHT3f2+hzYDGfRxmdh7B72l3nOrrY2bZjfcJdki+36zZLODW8CikycD+xs0kcdTit7NErr9mIv/ObgP+EKXNy8BlZpYXbh65LJwWU2Y2Hfg74Cp3P9xCm/b8LcSyxsj9VNe28Nrt+X+PpUuBVe5eHW1motfhKUn0nu5Y3AiOjvmA4KiE74bT7iH4BwDIJNjsUAXMB4bFsbYLCLq3S4HF4e0K4CvAV8I2dwLLCY6kmAecH8f6hoWvuySsoXH9RdZnwH3h+l0GVMT595tF8CGfGzEtoeuPIKC2AXUE316/QLCf6jVgTfgzP2xbATwQ8dw7wr/FKuD2ONVWRbAtvvFvsPFovEHAS639LcRx/f13+Pe1lOCDfmDzGsPHH/p/j0d94fRHGv/uItomZB121k3DXIiISJOeuPlIREROkUJBRESaKBRERKSJQkFERJooFEREpIlCQWLCzOaGP4eY2Wc7edn/J9prxYqZXROrkVbN7GCMljvNzF44zWU8YmbXtTL/TjO7/XReQ7oehYLEhLufH94dAnQoFMwstY0mJ4VCxGvFyt8CvzjdhbTjfcVceAZuZ3kI+EYnLk+6AIWCxETEN+AfAh8Nx5L/lpmlhmP5LwgHOvty2H6aBdeZ+C3BCUuY2XPhIGLLGwcSM7MfAr3D5T0W+VrhGdY/NrP3w/Hrb4hY9htm9owF1xB4LOKM5x+a2Yqwln+N8j5GAcfcfVf4+BEz+6WZ/cXMPjCzK8Pp7X5fUV7jB+HgffPMrH/E61wX0eZgxPJaei/Tw2lzCIZeaHzu3WZ2v5n9Gfh1K7Wamd0bro8XiRjAL9p68uBM6A3hWePSQ3TmtwaRaO4iGBO/8cNzJsGwGOeaWQbwdvhhBcGYMGe4+/rw8R3uvsfMegMLzOxZd7/LzO5097OjvNanCQZPGw8Uhs95K5w3ARhHMC7O28BUM1tBMHzCGHd3i36hmakEA+xFGgJcSDBY22wzGwHc2oH3FakPMM/dv2tmPwK+BPxTlHaRor2XSoLxgS4mOFu5+Vg8E4EL3P1IK7+DCcBo4EygP7ACeMjM8ltZT5UEo4TOb6Nm6SbUU5B4u4xg3KTFBEOGFwAjw3nzm31wfsPMGoeqKIto15ILgMc9GERtB/AmcG7Esqs9GFxtMcEH+wHgKPCAmX0aiDYG0ECgptm0p9y9wYOhktcBYzr4viIdBxq3/S8M62pLtPcyBljv7ms8GKbgN82eM8vdj4T3W6r1Y/x1/W0FXg/bt7aedhIM6yA9hHoKEm8G/A93P2nQNzObBhxq9vhSYIq7HzazNwjGrGpr2S05FnH/BMFVx+rDTR+XEAykdifBN+1IRwhG0Y3UfGwYp53vK4o6/+tYMyf46/9kPeGXtnDzUHpr76WFuiJF1tBSrVdEW0Yb6ymTYB1JD6GegsRaLcFlRxu9DHzVguHDMbNRFowe2VwusDcMhDEEl/1sVNf4/GbeAm4It5kXEXzzbXGzhgXXtMj1YHjtbxJsempuJTCi2bQZZpZiZsMJBjxb3YH31V4bCDb5QHAlsWjvN9IqYGhYEwSjyLakpVrfAm4M199A4KJwfmvraRRdfdRP6RD1FCTWlgL14WagR4CfEmzuWBR+A64h+mUq/wR8xcyWEnzozouYdz+w1MwWufvNEdN/D0whGJHSgb919+1hqESTDfzBzDIJvj1/K0qbt4B/MzOL+Ea/mmDTVH+CETKPmtkD7Xxf7fWrsLb5BCOsttbbIKxhJvCime0C5gBntNC8pVp/T9ADWEYw6uibYfvW1tNU4P92+N1Jl6VRUkXaYGY/BZ5391fN7BHgBXd/JsFlJZyZTQC+7e6fS3Qt0nm0+Uikbf9McA0HOVkh8A+JLkI6l3oKIiLSRD0FERFpolAQEZEmCgUREWmiUBARkSYKBRERafL/AYcsBzp21EPiAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ceb3336cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot learning curve (with costs)\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Interpretation**:\n",
    "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 - Further analysis (optional/ungraded exercise) ##\n",
    "\n",
    "Congratulations on building your first image classification model. Let's analyze it further, and examine possible choices for the learning rate $\\alpha$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Choice of learning rate ####\n",
    "\n",
    "**Reminder**:\n",
    "In order for Gradient Descent to work you must choose the learning rate wisely. The learning rate $\\alpha$  determines how rapidly we update the parameters. If the learning rate is too large we may \"overshoot\" the optimal value. Similarly, if it is too small we will need too many iterations to converge to the best values. That's why it is crucial to use a well-tuned learning rate.\n",
    "\n",
    "Let's compare the learning curve of our model with several choices of learning rates. Run the cell below. This should take about 1 minute. Feel free also to try different values than the three we have initialized the `learning_rates` variable to contain, and see what happens. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "learning rate is: 0.01\n",
      "train accuracy: 99.52153110047847 %\n",
      "test accuracy: 68.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.001\n",
      "train accuracy: 88.99521531100478 %\n",
      "test accuracy: 64.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "learning rate is: 0.0001\n",
      "train accuracy: 68.42105263157895 %\n",
      "test accuracy: 36.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ceb537f320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "for i in learning_rates:\n",
    "    print (\"learning rate is: \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations')\n",
    "\n",
    "legend = plt.legend(loc='upper center', shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Interpretation**: \n",
    "- Different learning rates give different costs and thus different predictions results.\n",
    "- If the learning rate is too large (0.01), the cost may oscillate up and down. It may even diverge (though in this example, using 0.01 still eventually ends up at a good value for the cost). \n",
    "- A lower cost doesn't mean a better model. You have to check if there is possibly overfitting. It happens when the training accuracy is a lot higher than the test accuracy.\n",
    "- In deep learning, we usually recommend that you: \n",
    "    - Choose the learning rate that better minimizes the cost function.\n",
    "    - If your model overfits, use other techniques to reduce overfitting. (We'll talk about this in later videos.) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 7 - Test with your own image (optional/ungraded exercise) ##\n",
    "\n",
    "Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:\n",
    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
    "    3. Change your image's name in the following code\n",
    "    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\software\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0.\n",
      "Use ``matplotlib.pyplot.imread`` instead.\n",
      "  import sys\n",
      "D:\\software\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:8: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1.0, your algorithm predicts a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2ceb370ec50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
    "my_image = \"aaaab.jpg\"   # change this to the name of your image file \n",
    "## END CODE HERE ##\n",
    "\n",
    "# We preprocess the image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(ndimage.imread(fname, flatten=False))\n",
    "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((1, num_px*num_px*3)).T\n",
    "my_predicted_image = predict(d[\"w\"], d[\"b\"], my_image)\n",
    "\n",
    "plt.imshow(image)\n",
    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**What to remember from this assignment:**\n",
    "1. Preprocessing the dataset is important.\n",
    "2. You implemented each function separately: initialize(), propagate(), optimize(). Then you built a model().\n",
    "3. Tuning the learning rate (which is an example of a \"hyperparameter\") can make a big difference to the algorithm. You will see more examples of this later in this course!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if you'd like, we invite you to try different things on this Notebook. Make sure you submit before trying anything. Once you submit, things you can play with include:\n",
    "    - Play with the learning rate and the number of iterations\n",
    "    - Try different initialization methods and compare the results\n",
    "    - Test other preprocessings (center the data, or divide each row by its standard deviation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bibliography:\n",
    "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n",
    "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "neural-networks-deep-learning",
   "graded_item_id": "XaIWT",
   "launcher_item_id": "zAgPl"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
